TypeScript Enum Alternativalari: Mustahkam Kod uchun `const` Tasdiqlari va Birlashma Turlarini O'rganish

JavaScript'ning kuchli ustki toʻplami boʻlgan TypeScript, veb-dasturlashning dinamik olamiga statik tiplashtirishni olib keladi. Uning ko'plab xususiyatlari orasida `enum` kalit so'zi uzoq vaqtdan beri nomlangan konstantalar to'plamini aniqlash uchun asosiy vosita bo'lib kelgan. Enumlar o'zaro bog'liq qiymatlar to'plamini aniq ifodalash usulini taqdim etib, o'qish qulayligi va tiplar xavfsizligini oshiradi.

Biroq, TypeScript ekotizimi rivojlanib, loyihalar murakkabligi va miqyosi o'sib borar ekan, butun dunyodagi dasturchilar `enum`larning an'anaviy foydaliligini tobora ko'proq shubha ostiga qo'yishmoqda. Oddiy holatlar uchun qulay bo'lsa-da, `enum`lar ba'zida kutilmagan muammolarga olib kelishi, paket hajmini (bundle size) ta'sir qilishi yoki tree-shaking optimallashtirishlarini murakkablashtirishi mumkin bo'lgan ma'lum xususiyatlar va ish vaqti xarakteristikalarini joriy qiladi. Bu esa alternativalarni keng miqyosda o'rganishga olib keldi.

Ushbu keng qamrovli qo'llanma TypeScript `enum`larining ikkita mashhur va yuqori samarali alternativalarini chuqur o'rganadi: Satr/Raqamli Literallar bilan Birlashma Turlari va `const` Tasdiqlari (`as const`). Biz ularning mexanizmlari, amaliy qo'llanilishi, afzalliklari va kamchiliklarini o'rganib chiqamiz, bu esa sizga loyihalaringiz uchun, ularning hajmidan yoki ular ustida ishlayotgan global jamoadan qat'i nazar, ongli ravishda loyihaviy qarorlar qabul qilish uchun bilim beradi. Maqsadimiz - sizga yanada mustahkam, qo'llab-quvvatlanishi oson va samarali TypeScript kodini yozish imkoniyatini berishdir.

TypeScript Enum: Qisqacha Takrorlash

Alternativalarga o'tishdan oldin, an'anaviy TypeScript `enum`ini qisqacha eslab o'tamiz. Enumlar dasturchilarga nomlangan konstantalar to'plamini aniqlash imkonini beradi, bu esa kodni o'qishni osonlashtiradi va ilova bo'ylab "sehrli satrlar" yoki "sehrli raqamlar" tarqalishining oldini oladi. Ular asosan ikki shaklda bo'ladi: raqamli va satrli enumlar.

Raqamli Enumlar

Standart holatda, TypeScript enumlari raqamlidir. Birinchi a'zo `0` bilan ishga tushiriladi va har bir keyingi a'zo avtomatik ravishda oshirib boriladi.

            enum Direction {
  Up,
  Down,
  Left,
  Right,
}

let currentDirection: Direction = Direction.Up;
console.log(currentDirection); // Chiqaradi: 0
console.log(Direction.Left);    // Chiqaradi: 2

            

              
                Copy
              
            
          

Siz raqamli enum a'zolarini qo'lda ham ishga tushirishingiz mumkin:

            enum StatusCode {
  Success = 200,
  NotFound = 404,
  ServerError = 500,
}

let status: StatusCode = StatusCode.NotFound;
console.log(status); // Chiqaradi: 404

            

              
                Copy
              
            
          

Raqamli enumlarning o'ziga xos xususiyati teskari xaritalash (reverse mapping) hisoblanadi. Ish vaqtida, raqamli enum nomlarni qiymatlarga va qiymatlarni qayta nomlarga xaritalaydigan JavaScript obyektiga kompilyatsiya qilinadi.

            enum UserRole {
  Admin = 1,
  Editor,
  Viewer,
}

console.log(UserRole[1]); // Chiqaradi: "Admin"
console.log(UserRole.Editor); // Chiqaradi: 2
console.log(UserRole[2]); // Chiqaradi: "Editor"

/*
JavaScript'ga kompilyatsiya qilinadi:
var UserRole;
(function (UserRole) {
    UserRole[UserRole["Admin"] = 1] = "Admin";
    UserRole[UserRole["Editor"] = 2] = "Editor";
    UserRole[UserRole["Viewer"] = 3] = "Viewer";
})(UserRole || (UserRole = {}));
*/

            

              
                Copy
              
            
          

Satrli Enumlar

Satrli enumlar ish vaqtida o'qilishi oson bo'lganligi sababli ko'pincha afzal ko'riladi, chunki ular avtomatik o'sadigan raqamlarga tayanmaydi. Har bir a'zo satr literali bilan ishga tushirilishi kerak.

            enum UserPermission {
  Read = "READ_PERMISSION",
  Write = "WRITE_PERMISSION",
  Delete = "DELETE_PERMISSION",
}

let permission: UserPermission = UserPermission.Write;
console.log(permission); // Chiqaradi: "WRITE_PERMISSION"

            

              
                Copy
              
            
          

Satrli enumlar teskari xaritalashga ega bo'lmaydi, bu esa kutilmagan ish vaqti xatti-harakatlaridan saqlanish va hosil qilingan JavaScript kodini kamaytirish uchun odatda yaxshi holatdir.

Enumlar Bilan Bog'liq Asosiy Mulohazalar va Potensial Xatolar

Enumlar qulaylik taklif qilsa-da, ular ehtiyotkorlik bilan ko'rib chiqilishi kerak bo'lgan ma'lum xususiyatlarga ega:

• Ish vaqti obyektlari: Ham raqamli, ham satrli enumlar ish vaqtida JavaScript obyektlarini hosil qiladi. Bu shuni anglatadiki, siz ularni faqat tiplarni tekshirish uchun ishlatsangiz ham, ular ilovangizning paket hajmiga hissa qo'shadi. Kichik loyihalar uchun bu ahamiyatsiz bo'lishi mumkin, ammo ko'plab enumlarga ega yirik miqyosli ilovalarda bu sezilarli bo'lishi mumkin.
• Tree-Shaking Yetishmasligi: Enumlar ish vaqti obyektlari bo'lganligi sababli, ular ko'pincha Webpack yoki Rollup kabi zamonaviy paketlovchilar tomonidan samarali tree-shaking qilinmaydi. Agar siz `enum`ni aniqlab, uning faqat bir yoki ikkita a'zosidan foydalansangiz, butun `enum` obyekti baribir yakuniy paketingizga kiritilishi mumkin. Bu esa keragidan kattaroq fayl hajmiga olib kelishi mumkin.
• Teskari Xaritalash (Raqamli Enumlar): Raqamli enumlarning teskari xaritalash xususiyati, ba'zan foydali bo'lsa-da, chalkashlik va kutilmagan xatti-harakatlarga sabab bo'lishi mumkin. U JavaScript kodiga qo'shimcha kod qo'shadi va har doim ham kerakli funksionallik bo'lmasligi mumkin. Masalan, raqamli enumlarni serializatsiya qilish ba'zan faqat raqamning o'zi saqlanishiga olib kelishi mumkin, bu esa satr kabi tavsiflovchi bo'lmasligi mumkin.
• Transpilyatsiya Yuklamasi: Enumlarni JavaScript obyektlariga kompilyatsiya qilish, shunchaki konstant o'zgaruvchilarni aniqlashga qaraganda qurish jarayoniga biroz qo'shimcha yuklama qo'shadi.
• Cheklangan Iteratsiya: Enum qiymatlari bo'yicha to'g'ridan-to'g'ri iteratsiya qilish, ayniqsa raqamli enumlarda teskari xaritalash tufayli, murakkab bo'lishi mumkin. Faqat kerakli qiymatlarni olish uchun sizga ko'pincha yordamchi funksiyalar yoki maxsus sikllar kerak bo'ladi.

Ushbu jihatlar nima uchun koʻplab global dasturlash jamoalari, ayniqsa ishlash samaradorligi va paket hajmiga eʼtibor qaratadiganlar, ish vaqtidagi iz qoldirmaydigan yoki boshqa murakkabliklarsiz shunga oʻxshash tiplar xavfsizligini taʼminlaydigan alternativalarni izlayotganini koʻrsatadi.

1-Alternativa: Literallar bilan Birlashma Turlari

TypeScript'dagi `enum`larga eng oddiy va kuchli alternativalardan biri bu Satr yoki Raqamli Literallar bilan Birlashma Turlaridan foydalanishdir. Bu yondashuv TypeScript'ning mustahkam tiplar tizimidan foydalanib, ish vaqtida hech qanday yangi tuzilmalarni joriy qilmasdan, kompilyatsiya vaqtida ma'lum, ruxsat etilgan qiymatlar to'plamini aniqlaydi.

Birlashma Turlari Nima?

Birlashma turi bir nechta turlardan biri bo'lishi mumkin bo'lgan qiymatni tavsiflaydi. Masalan, `string | number` o'zgaruvchi satr yoki raqamni saqlashi mumkinligini anglatadi. Literal turlar bilan birlashtirilganda (masalan, `"success"`, `404`), siz faqat ma'lum bir oldindan belgilangan qiymatlar to'plamini saqlaydigan tipni aniqlashingiz mumkin.

Amaliy Misol: Birlashma Turlari bilan Statuslarni Aniqlash

Keling, keng tarqalgan holatni ko'rib chiqaylik: ma'lumotlarni qayta ishlash ishi yoki foydalanuvchi hisobi uchun mumkin bo'lgan statuslar to'plamini aniqlash. Birlashma turlari bilan bu toza va ixcham ko'rinadi:

            type JobStatus = "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED";

function processJob(status: JobStatus): void {
  if (status === "COMPLETED") {
    console.log("Ish muvaffaqiyatli yakunlandi.");
  } else if (status === "FAILED") {
    console.log("Ishda xatolik yuz berdi.");
  } else {
    console.log(`Ish hozirda ${status} holatida.`);
  }
}

let currentJobStatus: JobStatus = "IN_PROGRESS";
processJob(currentJobStatus);

// Bu kompilyatsiya vaqtida xatolikka olib keladi:
// let invalidStatus: JobStatus = "CANCELLED"; // Xato: '"CANCELLED"' tipi 'JobStatus' tipiga tayinlanmaydi.

            

              
                Copy
              
            
          

Raqamli qiymatlar uchun ham pattern bir xil:

            type HttpCode = 200 | 400 | 404 | 500;

function handleResponse(code: HttpCode): void {
  if (code === 200) {
    console.log("Operatsiya muvaffaqiyatli.");
  } else if (code === 404) {
    console.log("Resurs topilmadi.");
  }
}

let responseStatus: HttpCode = 200;
handleResponse(responseStatus);

            

              
                Copy
              
            
          

E'tibor bering, biz bu yerda `type` taxallusini aniqlayapmiz. Bu faqat kompilyatsiya vaqtida mavjud bo'lgan tuzilma. JavaScript'ga kompilyatsiya qilinganda, `JobStatus` shunchaki yo'qoladi va literal satrlar/raqamlar to'g'ridan-to'g'ri ishlatiladi.

Literallar bilan Birlashma Turlarining Afzalliklari

Bu yondashuv bir nechta jiddiy afzalliklarni taqdim etadi:

• Faqat Kompilyatsiya Vaqtida: Birlashma turlari kompilyatsiya jarayonida to'liq o'chiriladi. Ular ish vaqtida hech qanday JavaScript kodi hosil qilmaydi, bu esa kichikroq paket hajmlariga va ilovaning tezroq ishga tushishiga olib keladi. Bu ishlash samaradorligi muhim bo'lgan va har bir kilobayt hisobga olinadigan global miqyosda joylashtirilgan ilovalar uchun katta afzallikdir.
• A'lo darajadagi Tiplar Xavfsizligi: TypeScript tayinlashlarni aniqlangan literal turlarga nisbatan qat'iy tekshiradi va faqat yaroqli qiymatlar ishlatilishini kuchli kafolatlaydi. Bu imlo xatolari yoki noto'g'ri qiymatlar bilan bog'liq keng tarqalgan xatolarning oldini oladi.
• Optimal Tree-Shaking: Ish vaqti obyekti yo'qligi sababli, birlashma turlari tabiiy ravishda tree-shakingni qo'llab-quvvatlaydi. Paketlovchingiz butun bir obyektni emas, balki faqat siz ishlatgan haqiqiy satr yoki raqamli literallarni kiritadi.
• O'qish Osonligi: Oddiy, aniq qiymatlar to'plami uchun tip ta'rifi ko'pincha juda aniq va tushunarli bo'ladi.
• Oddiylik: Hech qanday yangi til konstruksiyalari yoki murakkab kompilyatsiya artefaktlari kiritilmaydi. Bu shunchaki fundamental TypeScript tip xususiyatlaridan foydalanishdir.
• Qiymatlarga To'g'ridan-to'g'ri Kirish: Siz to'g'ridan-to'g'ri satr yoki raqam qiymatlari bilan ishlaysiz, bu esa serializatsiya va deserializatsiyani soddalashtiradi, ayniqsa ma'lum satr identifikatorlarini kutadigan API'lar yoki ma'lumotlar bazalari bilan ishlashda.

Literallar bilan Birlashma Turlarining Kamchiliklari

Birlashma turlari kuchli bo'lsa-da, ularning ba'zi cheklovlari ham mavjud:

• Bog'liq Ma'lumotlar uchun Takrorlanish: Agar siz har bir "enum" a'zosi bilan qo'shimcha ma'lumotlarni yoki metadatalarni (masalan, ko'rsatiladigan yorliq, ikonka, rang) bog'lashingiz kerak bo'lsa, buni to'g'ridan-to'g'ri birlashma turi ta'rifida qila olmaysiz. Odatda sizga alohida xaritalash obyekti kerak bo'ladi.
• Barcha Qiymatlar Bo'yicha To'g'ridan-to'g'ri Iteratsiya Yo'qligi: Ish vaqtida birlashma turidan barcha mumkin bo'lgan qiymatlar massivini olishning o'rnatilgan usuli yo'q. Masalan, siz `JobStatus`dan to'g'ridan-to'g'ri `["PENDING", "IN_PROGRESS", "COMPLETED", "FAILED"]` ni osonlikcha ololmaysiz. Bu ko'pincha, agar ularni UI'da (masalan, ochiladigan menyuda) ko'rsatish kerak bo'lsa, qiymatlarning alohida massivini saqlashni talab qiladi.
• Kamroq Markazlashtirilgan: Agar qiymatlar to'plami ham tip sifatida, ham ish vaqti qiymatlari massivi sifatida kerak bo'lsa, siz ro'yxatni ikki marta (bir marta tip sifatida, bir marta ish vaqti massivi sifatida) aniqlashingiz mumkin, bu esa sinxronizatsiyadan chiqish ehtimolini keltirib chiqarishi mumkin.

Ushbu kamchiliklarga qaramay, ko'plab holatlar uchun birlashma turlari zamonaviy JavaScript dasturlash amaliyotlariga yaxshi mos keladigan toza, samarali va tiplar xavfsizligiga ega yechimni taqdim etadi.

2-Alternativa: `const` Tasdiqlari (`as const`)

TypeScript 3.4 da kiritilgan `as const` tasdiqlashi, `enum`larga ajoyib alternativa taklif qiluvchi yana bir nihoyatda kuchli vositadir, ayniqsa sizga ish vaqti obyekti va mustahkam tip chiqarish kerak bo'lganda. U TypeScript'ga literal ifodalar uchun eng tor mumkin bo'lgan tipni chiqarish imkonini beradi.

`const` Tasdiqlari Nima?

O'zgaruvchiga, massivga yoki obyekt literaliga `as const` ni qo'llaganingizda, TypeScript ushbu literal ichidagi barcha xususiyatlarni `readonly` deb hisoblaydi va ularning kengroq tiplari (masalan, `string` o'rniga `"foo"`, `number` o'rniga `123`) o'rniga literal tiplarini chiqaradi. Bu ish vaqti ma'lumotlar tuzilmalaridan juda aniq birlashma turlarini hosil qilish imkonini beradi.

Amaliy Misol: `as const` yordamida "Psevdo-Enum" Obyektini Yaratish

Keling, ish statusi misolimizga qaytaylik. `as const` yordamida biz statuslarimiz uchun yagona haqiqat manbasini aniqlashimiz mumkin, bu ham ish vaqti obyekti, ham tip ta'riflari uchun asos bo'lib xizmat qiladi.

            const JobStatuses = {
  PENDING: "PENDING",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
} as const;

// JobStatuses.PENDING endi "PENDING" tipi sifatida chiqariladi (shunchaki string emas)
// JobStatuses quyidagi tip sifatida chiqariladi: {
//   readonly PENDING: "PENDING";
//   readonly IN_PROGRESS: "IN_PROGRESS";
//   readonly COMPLETED: "COMPLETED";
//   readonly FAILED: "FAILED";
// }

            

              
                Copy
              
            
          

Shu nuqtada, `JobStatuses` ish vaqtida oddiy `enum` kabi JavaScript obyekti hisoblanadi. Biroq, uning tip chiqarishi ancha aniqroqdir.

Birlashma Turlari uchun `typeof` va `keyof` bilan Birlashtirish

Haqiqiy kuch `as const`ni TypeScript'ning `typeof` va `keyof` operatorlari bilan birlashtirib, obyekt qiymatlari yoki kalitlaridan birlashma turini hosil qilganda namoyon bo'ladi.

            const JobStatuses = {
  PENDING: "PENDING",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
} as const;

// Kalitlarni ifodalovchi tip (masalan, "PENDING" | "IN_PROGRESS" | ...)
type JobStatusKeys = keyof typeof JobStatuses;

// Qiymatlarni ifodalovchi tip (masalan, "PENDING" | "IN_PROGRESS" | ...)
type JobStatusValues = typeof JobStatuses[keyof typeof JobStatuses];

function processJobWithConstAssertion(status: JobStatusValues): void {
  if (status === JobStatuses.COMPLETED) {
    console.log("Ish muvaffaqiyatli yakunlandi.");
  } else if (status === JobStatuses.FAILED) {
    console.log("Ishda xatolik yuz berdi.");
  } else {
    console.log(`Ish hozirda ${status} holatida.`);
  }
}

let currentJobStatusFromObject: JobStatusValues = JobStatuses.IN_PROGRESS;
processJobWithConstAssertion(currentJobStatusFromObject);

// Bu kompilyatsiya vaqtida xatolikka olib keladi:
// let invalidStatusFromObject: JobStatusValues = "CANCELLED"; // Xato!

            

              
                Copy
              
            
          

Bu pattern ikkala dunyoning eng yaxshi tomonlarini taqdim etadi: iteratsiya yoki to'g'ridan-to'g'ri xususiyatlarga kirish uchun ish vaqti obyekti va qat'iy tip tekshiruvi uchun kompilyatsiya vaqti birlashma turi.

Hosil Qilingan Birlashma Turlari bilan `const` Tasdiqlarining Afzalliklari

• Yagona Haqiqat Manbai: Siz konstantalaringizni bir marta oddiy JavaScript obyektida aniqlaysiz va undan ham ish vaqti kirishini, ham kompilyatsiya vaqti tiplarini hosil qilasiz. Bu turli dasturlash jamoalari bo'ylab takrorlanishni sezilarli darajada kamaytiradi va qo'llab-quvvatlashni yaxshilaydi.
• Tiplar Xavfsizligi: Sof birlashma turlariga o'xshab, siz a'lo darajadagi tiplar xavfsizligiga ega bo'lasiz, bu faqat oldindan belgilangan qiymatlar ishlatilishini ta'minlaydi.
• Ish Vaqtida Iteratsiya Qilish Imkoniyati: `JobStatuses` oddiy JavaScript obyekti bo'lganligi sababli, siz uning kalitlari yoki qiymatlari bo'yicha `Object.keys()`, `Object.values()` yoki `Object.entries()` kabi standart JavaScript usullari yordamida osonlikcha iteratsiya qilishingiz mumkin. Bu dinamik UI'lar (masalan, ochiladigan menyularni to'ldirish) yoki loglash uchun bebaho.
• Bog'liq Ma'lumotlar: Bu pattern tabiiy ravishda har bir "enum" a'zosi bilan qo'shimcha ma'lumotlarni bog'lashni qo'llab-quvvatlaydi.
• Yaxshiroq Tree-Shaking Potensiali (Enumlar bilan solishtirganda): `as const` ish vaqti obyektini yaratsa-da, bu standart JavaScript obyektidir. Zamonaviy paketlovchilar odatda ishlatilmagan xususiyatlarni yoki hatto agar ularga murojaat qilinmasa, butun obyektlarni TypeScript'ning `enum` kompilyatsiya natijasiga qaraganda samaraliroq tree-shaking qila oladi. Biroq, agar obyekt katta bo'lsa va faqat bir nechta xususiyat ishlatilsa, agar u granular tree-shakingni oldini oladigan tarzda import qilinsa, butun obyekt baribir kiritilishi mumkin.
• Moslashuvchanlik: Siz nafaqat satrlar yoki raqamlar, balki kerak bo'lganda murakkabroq obyektlar bo'lgan qiymatlarni ham aniqlashingiz mumkin, bu esa uni juda moslashuvchan pattern qiladi.

            const FileOperations = {
  UPLOAD: {
    label: "Faylni yuklash",
    icon: "upload-icon.svg",
    permission: "can_upload"
  },
  DOWNLOAD: {
    label: "Faylni yuklab olish",
    icon: "download-icon.svg",
    permission: "can_download"
  },
  DELETE: {
    label: "Faylni o'chirish",
    icon: "delete-icon.svg",
    permission: "can_delete"
  },
} as const;

type FileOperationType = keyof typeof FileOperations; // "UPLOAD" | "DOWNLOAD" | "DELETE"
type FileOperationDetail = typeof FileOperations[keyof typeof FileOperations]; // { label: string; icon: string; permission: string; }

function performOperation(opType: FileOperationType) {
  const details = FileOperations[opType];
  console.log(`Bajarilmoqda: ${details.label} (Ruxsat: ${details.permission})`);
}

performOperation("UPLOAD");

            

              
                Copy
              
            
          

`const` Tasdiqlarining Kamchiliklari

• Ish Vaqti Obyektining Mavjudligi: Sof birlashma turlaridan farqli o'laroq, bu yondashuv hali ham ish vaqtida JavaScript obyekti yaratadi. Bu standart obyekt bo'lib, `enum`larga qaraganda ko'pincha tree-shaking uchun yaxshiroq bo'lsa-da, u to'liq o'chirilmaydi.
• Biroz Ko'proq Sintaksisli Tip Ta'rifi: Birlashma turini hosil qilish (`keyof typeof ...` yoki `typeof ...[keyof typeof ...]`) birlashma turi uchun shunchaki literallarni sanab o'tishdan ko'ra biroz ko'proq sintaksis talab qiladi.
• Noto'g'ri Foydalanish Ehtimoli: Agar ehtiyotkorlik bilan ishlatilmasa, juda katta `as const` obyekti, agar uning tarkibi modullararo samarali tree-shaking qilinmasa, baribir paket hajmiga sezilarli hissa qo'shishi mumkin.

Ham mustahkam kompilyatsiya vaqti tiplarini tekshirish, ham ish vaqtida iteratsiya qilinishi yoki qo'shimcha ma'lumotlar taqdim etishi mumkin bo'lgan qiymatlar to'plami kerak bo'lgan holatlar uchun `as const` butun dunyodagi TypeScript dasturchilari orasida ko'pincha afzal ko'rilgan tanlovdir.

Alternativalarni Taqqoslash: Qachon Qaysinisidan Foydalanish Kerak?

Birlashma turlari va `const` tasdiqlari o'rtasidagi tanlov asosan sizning ish vaqtidagi mavjudlik, iteratsiya qilish imkoniyati va konstantalaringiz bilan qo'shimcha ma'lumotlarni bog'lash zaruriyati kabi maxsus talablaringizga bog'liq. Keling, qaror qabul qilish omillarini tahlil qilaylik.

Oddiylik va Mustahkamlik

• Birlashma Turlari: Sizga faqat kompilyatsiya vaqtida aniq satr yoki raqamli qiymatlar to'plami kerak bo'lganda eng yuqori darajadagi oddiylikni taklif qiladi. Ular eng yengil variantdir.
• `const` Tasdiqlari: Sizga ham kompilyatsiya vaqti tiplari xavfsizligi, ham so'rov qilinishi, iteratsiya qilinishi yoki qo'shimcha metadat ma'lumotlar bilan kengaytirilishi mumkin bo'lgan ish vaqti obyekti kerak bo'lganda yanada mustahkam patternni taqdim etadi. Boshlang'ich sozlash biroz ko'proq sintaksisli, ammo bu xususiyatlar bilan o'zini oqlaydi.

Ish Vaqti va Kompilyatsiya Vaqti Mavjudligi

• Birlashma Turlari: Faqat kompilyatsiya vaqtida mavjud bo'lgan tuzilmalardir. Ular mutlaqo hech qanday JavaScript kodi hosil qilmaydi. Bu paket hajmini minimallashtirish ustuvor bo'lgan va qiymatlarning o'zi ish vaqtida obyekt sifatida kirishga hojat bo'lmasdan yetarli bo'lgan ilovalar uchun idealdir.
• `const` Tasdiqlari: Ish vaqtida oddiy JavaScript obyekti hosil qiladi. Ushbu obyekt JavaScript kodingizda mavjud va ishlatilishi mumkin. Bu paket hajmiga qo'shilsa-da, u odatda TypeScript `enum`laridan samaraliroq va tree-shaking uchun yaxshiroq nomzoddir.

Iteratsiya Talablari

• Birlashma Turlari: Ish vaqtida barcha mumkin bo'lgan qiymatlar bo'yicha to'g'ridan-to'g'ri iteratsiya qilish usulini taklif qilmaydi. Agar siz ochiladigan menyuni to'ldirishingiz yoki barcha variantlarni ko'rsatishingiz kerak bo'lsa, siz ushbu qiymatlarning alohida massivini aniqlashingiz kerak bo'ladi, bu esa takrorlanishga olib kelishi mumkin.
• `const` Tasdiqlari: Bu yerda ustunlik qiladi. Siz standart JavaScript obyekti bilan ishlayotganingiz sababli, kalitlar, qiymatlar yoki kalit-qiymat juftliklari massivini olish uchun `Object.keys()`, `Object.values()` yoki `Object.entries()` dan osonlikcha foydalanishingiz mumkin. Bu ularni dinamik UI'lar yoki ish vaqti sanog'ini talab qiladigan har qanday holat uchun mukammal qiladi.

            const PaymentMethods = {
  CREDIT_CARD: "Kredit Karta",
  PAYPAL: "PayPal",
  BANK_TRANSFER: "Bank O'tkazmasi",
} as const;

type PaymentMethodType = keyof typeof PaymentMethods;

// Barcha kalitlarni olish (masalan, ichki mantiq uchun)
const methodKeys = Object.keys(PaymentMethods) as PaymentMethodType[];
console.log(methodKeys); // ["CREDIT_CARD", "PAYPAL", "BANK_TRANSFER"]

// Barcha qiymatlarni olish (masalan, ochiladigan menyuda ko'rsatish uchun)
const methodLabels = Object.values(PaymentMethods);
console.log(methodLabels); // ["Kredit Karta", "PayPal", "Bank O'tkazmasi"]

// Kalit-qiymat juftliklarini olish (masalan, xaritalash uchun)
const methodEntries = Object.entries(PaymentMethods);
console.log(methodEntries); // [["CREDIT_CARD", "Kredit Karta"], ...]

            

              
                Copy
              
            
          

Tree-Shaking Oqibatlari

• Birlashma Turlari: Ular faqat kompilyatsiya vaqtida mavjud bo'lganligi sababli, tabiiy ravishda tree-shaking qilinadi.
• `const` Tasdiqlari: Ular ish vaqti obyektini yaratsa-da, zamonaviy paketlovchilar ko'pincha ushbu obyektning ishlatilmagan xususiyatlarini TypeScript'ning hosil qilingan `enum` obyektlariga qaraganda samaraliroq tree-shaking qila oladi. Biroq, agar butun obyekt import qilinib, unga murojaat qilinsa, u kiritilishi mumkin. Ehtiyotkorlik bilan modul dizayni yordam berishi mumkin.

Eng Yaxshi Amaliyotlar va Gibrid Yondashuvlar

Bu har doim ham "yoki u, yoki bu" vaziyati emas. Ko'pincha, eng yaxshi yechim gibrid yondashuvni o'z ichiga oladi, ayniqsa katta, xalqarolashtirilgan ilovalarda:

• Hech qachon iteratsiya qilinmaydigan yoki bog'liq ma'lumotlarga ega bo'lmagan oddiy, sof ichki bayroqlar yoki identifikatorlar uchun, Birlashma Turlari odatda eng samarali va toza tanlovdir.
• Iteratsiya qilinishi, UI'larda ko'rsatilishi yoki boy bog'liq metadatalarga (yorliqlar, ikonlar yoki ruxsatlar kabi) ega bo'lishi kerak bo'lgan konstantalar to'plamlari uchun, `const` Tasdiqlari patterni afzalroqdir.
• O'qish Osonligi va Mahalliylashtirish uchun Birlashtirish: Ko'pgina jamoalar ichki identifikatorlar uchun `as const` dan foydalanadi va keyin alohida xalqarolashtirish (i18n) tizimidan mahalliylashtirilgan displey yorliqlarini oladi.

            // src/constants/order-status.ts
const OrderStatuses = {
  PENDING: "PENDING",
  PROCESSING: "PROCESSING",
  SHIPPED: "SHIPPED",
  DELIVERED: "DELIVERED",
  CANCELLED: "CANCELLED",
} as const;

type OrderStatus = typeof OrderStatuses[keyof typeof OrderStatuses];

export { OrderStatuses, type OrderStatus };

// src/i18n/uz.json
{
  "orderStatus": {
    "PENDING": "Tasdiqlash kutilmoqda",
    "PROCESSING": "Buyurtma qayta ishlanmoqda",
    "SHIPPED": "Jo'natildi",
    "DELIVERED": "Yetkazib berildi",
    "CANCELLED": "Bekor qilindi"
  }
}

// src/components/OrderStatusDisplay.tsx
import { OrderStatuses, type OrderStatus } from "../constants/order-status";
import { useTranslation } from "react-i18next"; // Misol i18n kutubxonasi

interface OrderStatusDisplayProps {
  status: OrderStatus;
}

function OrderStatusDisplay({ status }: OrderStatusDisplayProps) {
  const { t } = useTranslation();
  const displayLabel = t(`orderStatus.${status}`);
  return <span>Holat: {displayLabel}</span>;
}

// Foydalanish:
// <OrderStatusDisplay status={OrderStatuses.DELIVERED} />

            

              
                Copy
              
            
          

Ushbu gibrid yondashuv `as const`ning tiplar xavfsizligi va ish vaqtidagi iteratsiya imkoniyatlaridan foydalanadi, shu bilan birga mahalliylashtirilgan matnlarni alohida va boshqariladigan holda saqlaydi, bu global ilovalar uchun muhim ahamiyatga ega.

Ilg'or Paterrnlar va Mulohazalar

Asosiy foydalanishdan tashqari, ham birlashma turlari, ham `const` tasdiqlari kod sifati va qo'llab-quvvatlanishini yanada oshirish uchun yanada murakkab patternlarga integratsiya qilinishi mumkin.

Birlashma Turlari bilan Tiplarni Himoyalash (Type Guards)

Birlashma turlari bilan ishlashda, ayniqsa birlashma turli xil tiplarni (faqat literallarni emas) o'z ichiga olganda, tiplarni toraytirish uchun tiplarni himoyalash (type guards) muhim ahamiyatga ega. Literal birlashma turlari bilan, diskriminatsiyalangan birlashmalar katta kuchga ega.

            type SuccessEvent = { type: "SUCCESS"; data: any; };
type ErrorEvent = { type: "ERROR"; message: string; code: number; };

type SystemEvent = SuccessEvent | ErrorEvent;

function handleSystemEvent(event: SystemEvent) {
  if (event.type === "SUCCESS") {
    console.log("Ma'lumotlar qabul qilindi:", event.data);
    // 'event' endi SuccessEvent'ga toraytirildi
  } else {
    console.log("Xatolik yuz berdi:", event.message, "Kod:", event.code);
    // 'event' endi ErrorEvent'ga toraytirildi
  } 
}

handleSystemEvent({ type: "SUCCESS", data: { user: "Alice" } });
handleSystemEvent({ type: "ERROR", message: "Tarmoq xatosi", code: 503 });

            

              
                Copy
              
            
          

Ko'pincha "diskriminatsiyalangan birlashmalar" deb ataladigan ushbu pattern, umumiy literal xususiyat (diskriminator) asosida ma'lumotlaringizning tuzilishi haqida kompilyatsiya vaqti kafolatlarini taqdim etib, juda mustahkam va tiplar xavfsizligiga ega.

`Object.values()` ni `as const` va Tip Tasdiqlari bilan Ishlatish

`as const` patternidan foydalanganda, `Object.values()` juda foydali bo'lishi mumkin. Biroq, TypeScript'ning `Object.values()` uchun standart tip chiqarishi kutilganidan kengroq bo'lishi mumkin (masalan, aniq literallar birlashmasi o'rniga `string[]`). Qat'iylik uchun sizga tip tasdiqlashi kerak bo'lishi mumkin.

            const Statuses = {
  ACTIVE: "Faol",
  INACTIVE: "Nofaol",
  PENDING: "Kutilmoqda",
} as const;

type StatusValue = typeof Statuses[keyof typeof Statuses]; // "Faol" | "Nofaol" | "Kutilmoqda"

// Object.values(Statuses) (string | "Faol" | "Nofaol" | "Kutilmoqda")[] sifatida chiqariladi
// Agar kerak bo'lsa, uni torroq qilib tasdiqlashimiz mumkin:
const allStatusValues: StatusValue[] = Object.values(Statuses);

console.log(allStatusValues); // ["Faol", "Nofaol", "Kutilmoqda"]

// Ochiladigan menyu uchun, agar ular farq qilsa, qiymatlarni yorliqlar bilan juftlashtirishingiz mumkin
const statusOptions = Object.entries(Statuses).map(([key, value]) => ({
  value: key, // Haqiqiy identifikator sifatida kalitni ishlating
  label: value // Ko'rsatish yorlig'i sifatida qiymatni ishlating
}));
console.log(statusOptions);
/*
[
  { value: "ACTIVE", label: "Faol" },
  { value: "INACTIVE", label: "Nofaol" },
  { value: "PENDING", label: "Kutilmoqda" }
]
*/

            

              
                Copy
              
            
          

Bu literal tiplarni saqlagan holda UI elementlari uchun mos bo'lgan kuchli tiplashtirilgan qiymatlar massivini qanday olishni ko'rsatadi.

Xalqarolashtirish (i18n) va Mahalliylashtirilgan Yorliqlar

Global ilovalar uchun mahalliylashtirilgan satrlarni boshqarish juda muhimdir. TypeScript `enum`lari va ularning alternativalari ichki identifikatorlarni taqdim etsa-da, ko'rsatiladigan yorliqlar ko'pincha i18n uchun ajratilishi kerak. `as const` patterni i18n tizimlari bilan ajoyib tarzda birga ishlaydi.

Siz o'zingizning ichki, o'zgarmas identifikatorlaringizni `as const` yordamida aniqlaysiz. Bu identifikatorlar barcha tillarda bir xil bo'lib, tarjima fayllaringiz uchun kalit bo'lib xizmat qiladi. Haqiqiy ko'rsatiladigan satrlar esa foydalanuvchining tanlangan tiliga qarab i18n kutubxonasidan (masalan, `react-i18next`, `vue-i18n`, `FormatJS`) olinadi.

            // app/features/product/constants.ts
export const ProductCategories = {
  ELECTRONICS: "ELECTRONICS",
  APPAREL: "APPAREL",
  HOME_GOODS: "HOME_GOODS",
  BOOKS: "BOOKS",
} as const;

export type ProductCategory = typeof ProductCategories[keyof typeof ProductCategories];

// app/i18n/locales/uz.json
{
  "productCategories": {
    "ELECTRONICS": "Elektronika",
    "APPAREL": "Kiyim-kechak va Aksessuarlar",
    "HOME_GOODS": "Uy-ro'zg'or buyumlari",
    "BOOKS": "Kitoblar"
  }
}

// app/i18n/locales/es.json
{
  "productCategories": {
    "ELECTRONICS": "Electrónica",
    "APPAREL": "Ropa y Accesorios",
    "HOME_GOODS": "Artículos para el hogar",
    "BOOKS": "Libros"
  }
}

// app/components/ProductCategorySelector.tsx
import { ProductCategories, type ProductCategory } from "../features/product/constants";
import { useTranslation } from "react-i18next";

function ProductCategorySelector() {
  const { t } = useTranslation();

  return (
    <select>
      {Object.values(ProductCategories).map(categoryKey => (
        <option key={categoryKey} value={categoryKey}>
          {t(`productCategories.${categoryKey}`)}
        </option>
      ))}
    </select>
  );
}

            

              
                Copy
              
            
          

Vazifalarni bunday ajratish kengaytiriladigan, global ilovalar uchun juda muhimdir. TypeScript tiplari siz doimo yaroqli kalitlardan foydalanayotganingizni ta'minlaydi, i18n tizimi esa foydalanuvchining lokaliga qarab taqdimot qatlamini boshqaradi. Bu xalqaro jamoalar uchun keng tarqalgan anti-pattern bo'lgan tilga bog'liq satrlarni to'g'ridan-to'g'ri ilovangizning asosiy mantig'iga joylashtirishdan saqlaydi.

Xulosa: TypeScript Loyihalash Tanlovlaringizni Kuchaytirish

TypeScript rivojlanishda davom etar ekan va butun dunyodagi dasturchilarga yanada mustahkam va kengaytiriladigan ilovalar yaratish imkonini berar ekan, uning nozik xususiyatlari va alternativalarini tushunish tobora muhimroq bo'lib bormoqda. TypeScript'ning `enum` kalit so'zi nomlangan konstantalarni aniqlashning qulay usulini taklif qilsa-da, uning ish vaqtidagi izi, tree-shaking cheklovlari va teskari xaritalash murakkabliklari ko'pincha zamonaviy alternativalarni ishlash samaradorligiga sezgir yoki katta miqyosli loyihalar uchun jozibadorroq qiladi.

Satr/Raqamli Literallar bilan Birlashma Turlari eng yengil va eng kompilyatsiya vaqtiga yo'naltirilgan yechim sifatida ajralib turadi. Ular ish vaqtida hech qanday JavaScript kodi hosil qilmasdan murosasiz tiplar xavfsizligini ta'minlaydi, bu esa minimal paket hajmi va maksimal tree-shaking ustuvor bo'lgan va ish vaqti sanog'i muammo bo'lmagan holatlar uchun idealdir.

Boshqa tomondan, `const` Tasdiqlari (`as const`) `typeof` va `keyof` bilan birgalikda juda moslashuvchan va kuchli patternni taklif qiladi. Ular sizning konstantalaringiz uchun yagona haqiqat manbasini, kuchli kompilyatsiya vaqti tiplari xavfsizligini va ish vaqtida qiymatlar bo'yicha iteratsiya qilishning muhim imkoniyatini ta'minlaydi. Ushbu yondashuv ayniqsa konstantalaringiz bilan qo'shimcha ma'lumotlarni bog'lash, dinamik UI'larni to'ldirish yoki xalqarolashtirish tizimlari bilan muammosiz integratsiya qilish kerak bo'lgan vaziyatlar uchun juda mos keladi.

Ish vaqti izi, iteratsiya ehtiyojlari va bog'liq ma'lumotlarning murakkabligi kabi o'zaro kelishuvlarni diqqat bilan ko'rib chiqib, siz toza, samaraliroq va qo'llab-quvvatlanishi osonroq TypeScript kodiga olib keladigan ongli qarorlar qabul qilishingiz mumkin. Ushbu alternativalarni qabul qilish shunchaki "zamonaviy" TypeScript yozish emas; bu sizning ilovangizning ishlash samaradorligini, dasturchi tajribasini va global auditoriya uchun uzoq muddatli barqarorligini oshiradigan ongli arxitektura tanlovlarini amalga oshirishdir.

Yaxshiroq alternativalar mavjud bo'lganda standart enumdan voz kechib, to'g'ri vazifa uchun to'g'ri vositani tanlash orqali TypeScript dasturlashingizni kuchaytiring.